"""
工作流CLI命令

提供工作流创建、执行、管理等命令。
"""

import click
import json
from pathlib import Path
from typing import Dict, Any

from rich.console import Console
from rich.table import Table
from rich.panel import Panel
from rich.text import Text

console = Console()


class WorkflowCommand:
    """工作流命令类"""

    def __init__(self):
        pass
    
    def register_commands(self, group):
        """注册命令到组"""
        # 使用内联函数定义Click命令
        @group.command()
        @click.argument('name')
        @click.option('--description', '-d', help='工作流描述')
        @click.option('--template', '-t', help='基于模板创建')
        @click.option('--output', '-o', type=click.Path(), help='输出文件路径')
        def create(name, description, template, output):
            """创建新的工作流"""
            return self.create_workflow(name, description, template, output)

        @group.command()
        @click.option('--format', '-f', type=click.Choice(['table', 'json', 'yaml']), default='table', help='输出格式')
        def list(format):
            """列出工作流"""
            return self.list_workflows(format)

        @group.command()
        @click.argument('workflow_file', type=click.Path(exists=True))
        def validate(workflow_file):
            """验证工作流定义"""
            return self.validate_workflow(workflow_file)

        @group.command()
        @click.argument('template_name')
        @click.option('--name', '-n', required=True, help='工作流名称')
        @click.option('--description', '-d', help='工作流描述')
        @click.option('--output', '-o', type=click.Path(), help='输出文件路径')
        def template(template_name, name, description, output):
            """基于模板创建工作流"""
            return self.create_from_template(template_name, name, description, output)
    
    def create_workflow(self, name, description, template, output):
        """
        创建新的工作流
        
        NAME: 工作流名称
        """
        console.print(f"🔧 创建工作流: [cyan]{name}[/cyan]")
        
        try:
            if template:
                workflow_data = self._create_from_template(name, description, template)
            else:
                workflow_data = self._create_basic_workflow(name, description)

            # 保存工作流
            if not output:
                output = f"{name.lower().replace(' ', '_')}_workflow.json"

            # 保存到文件
            with open(output, 'w', encoding='utf-8') as f:
                json.dump(workflow_data, f, indent=2, ensure_ascii=False)

            console.print(f"✅ 工作流已创建: [green]{output}[/green]")
            self._display_workflow_info(workflow_data)

        except Exception as e:
            console.print(f"❌ 创建失败: {e}", style="red")
    
    def _create_basic_workflow(self, name, description):
        """创建基础工作流"""
        # 创建简化的工作流定义
        workflow_data = {
            'name': name,
            'description': description or '基础视频处理工作流',
            'version': '1.0.0',
            'nodes': {
                'input': {
                    'type': 'input',
                    'name': '视频输入',
                    'data': {'video_directory': '/input'}
                },
                'scan': {
                    'type': 'processing',
                    'name': '视频扫描',
                    'processor': 'video_scan'
                },
                'analyze': {
                    'type': 'processing',
                    'name': '视频分析',
                    'processor': 'video_analysis'
                },
                'classify': {
                    'type': 'processing',
                    'name': 'AI分类',
                    'processor': 'ai_classification'
                },
                'output': {
                    'type': 'output',
                    'name': '处理结果',
                    'output_key': 'processed_videos'
                }
            },
            'connections': [
                {'from': 'input', 'to': 'scan'},
                {'from': 'scan', 'to': 'analyze'},
                {'from': 'analyze', 'to': 'classify'},
                {'from': 'classify', 'to': 'output'}
            ],
            'config': {
                'timeout': 3600,
                'retry_count': 3
            },
            'tags': ['video', 'processing', 'ai']
        }

        return workflow_data
    
    def _create_from_template(self, name, description, template_name):
        """从模板创建工作流"""
        # 简化的模板创建
        if template_name == 'video_processing':
            return self._create_video_processing_template(name, description)
        elif template_name == 'batch_classification':
            return self._create_batch_classification_template(name, description)
        elif template_name == 'product_showcase':
            return self._create_product_showcase_template(name, description)
        else:
            raise ValueError(f"未知模板: {template_name}")
    
    def _create_video_processing_template(self, name, description):
        """创建视频处理模板"""
        return {
            'name': name,
            'description': description or '视频处理工作流',
            'version': '1.0.0',
            'nodes': {
                'input': {'type': 'input', 'name': '视频输入'},
                'validate': {'type': 'processing', 'name': '视频验证'},
                'convert': {'type': 'processing', 'name': '视频转换'},
                'extract': {'type': 'processing', 'name': '元数据提取'},
                'output': {'type': 'output', 'name': '处理结果'}
            },
            'connections': [
                {'from': 'input', 'to': 'validate'},
                {'from': 'validate', 'to': 'convert'},
                {'from': 'convert', 'to': 'extract'},
                {'from': 'extract', 'to': 'output'}
            ]
        }
    
    def _create_batch_classification_template(self, name, description):
        """创建批量分类模板"""
        return {
            'name': name,
            'description': description or '批量分类工作流',
            'version': '1.0.0',
            'nodes': {
                'input': {'type': 'input', 'name': '批量输入'},
                'scan': {'type': 'processing', 'name': '文件扫描'},
                'classify': {'type': 'parallel', 'name': '并行分类'},
                'output': {'type': 'output', 'name': '分类结果'}
            },
            'connections': [
                {'from': 'input', 'to': 'scan'},
                {'from': 'scan', 'to': 'classify'},
                {'from': 'classify', 'to': 'output'}
            ]
        }

    def _create_product_showcase_template(self, name, description):
        """创建产品展示模板"""
        return {
            'name': name,
            'description': description or '产品展示工作流',
            'version': '1.0.0',
            'nodes': {
                'input': {'type': 'input', 'name': '产品视频输入'},
                'recognize': {'type': 'processing', 'name': '产品识别'},
                'generate': {'type': 'processing', 'name': '展示视频生成'},
                'jianying': {'type': 'processing', 'name': '剪映草稿生成'},
                'output': {'type': 'output', 'name': '展示结果'}
            },
            'connections': [
                {'from': 'input', 'to': 'recognize'},
                {'from': 'recognize', 'to': 'generate'},
                {'from': 'generate', 'to': 'jianying'},
                {'from': 'jianying', 'to': 'output'}
            ]
        }
    
    def _display_workflow_info(self, workflow_data):
        """显示工作流信息"""
        info_table = Table(title="工作流信息", show_header=False)
        info_table.add_column("属性", style="cyan", no_wrap=True)
        info_table.add_column("值", style="white")

        info_table.add_row("名称", workflow_data.get('name', '未知'))
        info_table.add_row("描述", workflow_data.get('description', '无'))
        info_table.add_row("版本", workflow_data.get('version', '1.0.0'))
        info_table.add_row("节点数量", str(len(workflow_data.get('nodes', {}))))
        info_table.add_row("连接数量", str(len(workflow_data.get('connections', []))))

        console.print(info_table)

        # 节点信息
        nodes = workflow_data.get('nodes', {})
        if nodes:
            nodes_text = Text()
            nodes_text.append("🔧 节点列表\n", style="bold")
            for node_id, node_info in nodes.items():
                nodes_text.append(f"{node_id}: {node_info.get('name', '未知')} ({node_info.get('type', '未知')})\n")

            panel = Panel(nodes_text, title="节点信息", border_style="blue")
            console.print(panel)
    

    
    def list_workflows(self, format):
        """列出可用的工作流模板"""
        console.print("📋 可用工作流模板")
        
        templates = {
            'video_processing': {
                'name': '视频处理',
                'description': '基础视频处理工作流，包含验证、转换、元数据提取',
                'nodes': 5,
                'tags': ['video', 'processing']
            },
            'batch_classification': {
                'name': '批量分类',
                'description': '批量视频AI分类工作流，支持并行处理',
                'nodes': 4,
                'tags': ['ai', 'classification', 'batch']
            },
            'product_showcase': {
                'name': '产品展示',
                'description': '产品展示视频生成工作流，包含剪映草稿生成',
                'nodes': 6,
                'tags': ['product', 'showcase', 'jianying']
            }
        }
        
        if format == 'json':
            console.print(json.dumps(templates, indent=2, ensure_ascii=False))
        else:
            table = Table(title="工作流模板", show_header=True, header_style="bold magenta")
            table.add_column("模板ID", style="cyan", no_wrap=True)
            table.add_column("名称", style="white")
            table.add_column("描述", style="dim")
            table.add_column("节点数", style="green")
            table.add_column("标签", style="yellow")
            
            for template_id, template_info in templates.items():
                table.add_row(
                    template_id,
                    template_info['name'],
                    template_info['description'],
                    str(template_info['nodes']),
                    ', '.join(template_info['tags'])
                )
            
            console.print(table)
    
    def validate_workflow(self, workflow_file):
        """
        验证工作流定义

        WORKFLOW_FILE: 工作流定义文件
        """
        console.print(f"✅ 验证工作流: [cyan]{workflow_file}[/cyan]")

        try:
            # 加载工作流文件
            with open(workflow_file, 'r', encoding='utf-8') as f:
                workflow_data = json.load(f)

            # 基本验证
            errors = []

            if 'name' not in workflow_data:
                errors.append("缺少工作流名称")

            if 'nodes' not in workflow_data:
                errors.append("缺少节点定义")
            elif not workflow_data['nodes']:
                errors.append("节点列表为空")

            if 'connections' not in workflow_data:
                errors.append("缺少连接定义")

            # 验证节点连接
            nodes = workflow_data.get('nodes', {})
            connections = workflow_data.get('connections', [])

            for conn in connections:
                if 'from' not in conn or 'to' not in conn:
                    errors.append("连接定义不完整")
                elif conn['from'] not in nodes or conn['to'] not in nodes:
                    errors.append(f"连接引用了不存在的节点: {conn['from']} -> {conn['to']}")

            if errors:
                console.print("❌ 验证失败:", style="red")
                for error in errors:
                    console.print(f"  • {error}", style="red")
            else:
                console.print("✅ 工作流验证通过", style="green")
                self._display_workflow_info(workflow_data)

        except json.JSONDecodeError as e:
            console.print(f"❌ JSON格式错误: {e}", style="red")
        except Exception as e:
            console.print(f"❌ 验证失败: {e}", style="red")
    

    
    def create_from_template(self, template_name, name, description, output):
        """
        基于模板创建工作流
        
        TEMPLATE_NAME: 模板名称
        """
        console.print(f"📋 基于模板创建工作流: [cyan]{template_name}[/cyan]")
        
        try:
            workflow = self._create_from_template(name, description, template_name)
            
            # 保存工作流
            if not output:
                output = f"{name.lower().replace(' ', '_')}_workflow.json"
            
            workflow.save_to_file(output)
            
            console.print(f"✅ 工作流已创建: [green]{output}[/green]")
            self._display_workflow_info(workflow)
            
        except Exception as e:
            console.print(f"❌ 创建失败: {e}", style="red")
